﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Windows.Forms;
using System.Drawing;
using System.ComponentModel;

namespace Cataloger.Kontrolki
{
    /// <summary>
    /// Kontrolka reprezantujaca drzewo katalogow, ściśle powiązana z ListviewCataloger
    /// W razie dlugiego czasu ładowania można sprobowac dynamicznie ładować zawartość
    /// korzystając ze zdarzenia BeforeExpand
    /// </summary>
    public class TreeViewCataloger : TreeView,IListaDrzewo
    {
		#region Fields (3) 

        /// <summary>
        /// poprzednio wskazywane myszką TreeNode, służy jako odniesienie do porównania z bieżacym wskazywanym myszką TreeNodem
        /// </summary>
        TreeNode prevNode = null;
        /// <summary>
        /// poprzedni zaznaczony TreeNode
        /// </summary>
        TreeNode prevNodeSelected = null;
        /// <summary>
        /// Tooltip w którym wyświetlane bedą podpowiedzi typu tooltip
        /// </summary>
        ToolTip toolTipTree = new ToolTip();

		#endregion Fields 

		#region Constructors (1) 

        public TreeViewCataloger()
        {
            Initialize();
            ustawieniaToolTip();
        }

		#endregion Constructors 

		#region Properties (12) 

        /// <summary>
        /// Etykieta powiązana na której wyśwetlana jest ścieżka obecnie zaznaczonego obiektu
        /// </summary>
        public Label LblPowiazane {get; set;}

        /// <summary>
        /// Powiązana kontrolka stanowi obok tej kontrolki podstawe do wyświetlania obiektów 
        /// </summary>
        public ListViewCataloger ListViewPowiazane {get;set;}

        /// <summary>
        /// Menu konektsowe obiektu Folder
        /// </summary>
        public ContextMenuStrip MenuFolder { get; set; }

        /// <summary>
        /// Menu konektsowe obiektu Katalog
        /// </summary>
        public ContextMenuStrip MenuKatalog { get; set; }

        /// <summary>
        /// Menu konektsowe obiektu Katalogi
        /// </summary>
        public ContextMenuStrip MenuKatalogi { get; set; }

        /// <summary>
        /// Menu konektsowe obiektu Nośnik
        /// </summary>
        public ContextMenuStrip MenuNosnik { get; set; }

        /// <summary>
        /// Pole picture box w którym znajduje się dioda sygnalizujaca czy dany obiekt jest dostępny
        /// </summary>
        public PictureBox PctBoxPowiazane
        {
            get;
            set;
        }

        //PictureBox pctBoxPowiazane=new PictureBox();
        public RichTextBox RichTextBoxSkojarzone
        {
            get;
            set;
        }

        public ToolStripItem ToolStripLab1 { get; set; }

        public ToolStripItem ToolStripLab2 { get; set; }

        public ToolStripItem ToolStripLab3 { get; set; }

        [Browsable(false)]
        public TreeNode WczesniejszyTNode
        {
            get { return prevNodeSelected; }
            set { prevNodeSelected = value; }
        }

		#endregion Properties 

		#region Methods (21) 

		// Public Methods (12) 

        public void CzyscInfo()
        {
            RichTextBoxSkojarzone.Text = "";
            PctBoxPowiazane.Image = null;
            LblPowiazane.Text = "";
            ToolStripLab1.Text = "";
            ToolStripLab2.Text = "";
            ToolStripLab3.Image = null;
        }

        public void DostepnoscKatalogu(Katalog temp)
        {
            if (temp.JestHaslo)
            {
                this.PctBoxPowiazane.Image = Properties.Resources.zabezpieczony;
                this.ToolStripLab3.Image = Properties.Resources.zabezpieczony;
            }
            else
            {
                this.PctBoxPowiazane.Image = Properties.Resources.niezabezpieczony;
                this.ToolStripLab3.Image = Properties.Resources.niezabezpieczony;
            }
        }

        public void InfoMoznaUruchomic(IUruchom uruchom)
        {
            if (uruchom.CzyIstniejeSciezka)
            {
                this.PctBoxPowiazane.Image = Properties.Resources.green;
                this.ToolStripLab3.Image = Properties.Resources.green;
            }
            else
            {
                this.PctBoxPowiazane.Image = Properties.Resources.red;
                this.ToolStripLab3.Image = Properties.Resources.red;
            }
        }

        public void OdswiezNosnik(Nosnik nos)
        {
            WyladujNosnik(nos);
            ZaladujNosnik(nos);
        }

        public void OpisObiektu(IInfo temp)
        {
            LblPowiazane.Text = temp.SciezkaWKatalogu;
            RichTextBoxSkojarzone.Text = temp.Opis;
            this.ToolStripLab1.Text = temp.OpisStatusStrip;
        }

        public void OpisToolsrip2(IObiektCatalogera obiekt)
        {
            if (obiekt is Katalog)
            {
                Katalog temp = obiekt as Katalog;
                this.ToolStripLab2.Text = string.Format("Wylistowane elementy: {0} ({1})", temp.LiczbaNosnikow.ToString(), temp.RozmiarDanych.ToProperUnit());
            }
            else if (obiekt is Nosnik)
            {
                Nosnik temp = obiekt as Nosnik;
                this.ToolStripLab2.Text = string.Format("Wylistowane elementy: {0} ({1})", temp.Root.ObiektyDyskowe.Count.ToString(), temp.RaportSkan.RozmiarZeskanowany.ToProperUnit());

            }
            else if (obiekt is ObiektDyskowy)
            {
                Folder temp = obiekt as Folder;
                this.ToolStripLab2.Text = string.Format("Wylistowane elementy: {0} ({1})", temp.ObiektyDyskowe.Count.ToString(), temp.Rozmiar.ToProperUnit());

            }
        }

        public void WyladujKatalog(Katalog kat)
        {
            try
            {

                foreach (TreeNode tn in this.Nodes[0].Nodes)
                {
                    if (tn.Tag == kat)
                    {
                        tn.Remove();
                        this.Refresh();
                    }
                }
                this.CzyscInfo();

            }
            catch { }
        }

        public void WyladujNosnik(Nosnik nos)
        {
            try
            {

                foreach (TreeNode tn in this.Nodes[0].Nodes)
                {
                    if (tn.Tag == nos.Katalog)
                    {
                        foreach (TreeNode item in tn.Nodes)
                        {
                            if (item.Tag == nos)
                            {
                                item.Remove();
                                this.Refresh();
                            }
                        }

                    }
                }

            }
            catch { }
        }

        public void WyladujWszystkieKatalogi()
        {
            try
            {
                foreach (TreeNode tn in this.Nodes[0].Nodes)
                {
                    tn.Remove();
                }
                this.Refresh();
                this.CzyscInfo();                
            }
            catch { }
        }

        public void ZaladujKatalog(Katalog kat)
        {
            try
            {
                this.BeginUpdate();
                this.Nodes["katalogi"].Nodes.Add(new TreeNodeCataloger(kat));
                this.Nodes["katalogi"].Expand();
                this.Nodes["katalogi"].Nodes[kat.Nazwa].EnsureVisible();
                this.SelectedNode = this.Nodes["katalogi"].Nodes[kat.Nazwa];                
                this.EndUpdate();
                kat.DodanoNosnik += new EventHandler<NosnikEventArgs>(kat_DodanoNosnik);
                kat.UsunietoNosnik += new EventHandler<NosnikEventArgs>(kat_UsunietoNosnik);
              
            }
            catch { }

        }

        public void ZaladujKatalogi(Katalogi kats)
        {
            this.ListViewPowiazane.Items.Clear();
            this.BeginUpdate();
            for (int i = 0; i < kats.Count; i++)
            {
                this.ZaladujKatalog(kats[i]);
            }
            this.EndUpdate();
        }

        public void ZaladujNosnik(Nosnik nos)
        {
            try
            {
                this.BeginUpdate();
                this.Nodes["katalogi"].Nodes[nos.Katalog.ToString()].Nodes.Add(new TreeNodeCataloger(nos));
                this.Nodes["katalogi"].Nodes[nos.Katalog.ToString()].Expand();
                this.Nodes["katalogi"].Nodes[nos.Katalog.ToString()].Nodes[nos.Nazwa].EnsureVisible();
                this.SelectedNode = this.Nodes["katalogi"].Nodes[nos.Katalog.ToString()].Nodes[nos.Nazwa];
                this.EndUpdate();
            }
            catch { }
        }
		// Protected Methods (4) 

        protected override void OnAfterSelect(TreeViewEventArgs e)
        {
            base.OnAfterSelect(e);
            CzyscInfo();
            
            if (SelectedNode.Tag is IInfo)
            {
                IInfo temp = SelectedNode.Tag as IInfo;
                OpisObiektu(temp);

            }
            if (e.Node.Tag is IUruchom)
            {
                IUruchom uruchom = e.Node.Tag as IUruchom;
                InfoMoznaUruchomic(uruchom);
            }
            if (e.Node.Tag is IObiektCatalogera)
            {
                IObiektCatalogera ob=e.Node.Tag as IObiektCatalogera;
                OpisToolsrip2(ob);
            }
            if (Convert.ToString(e.Node.Tag) == "Katalogi")
            {
                if (prevNodeSelected != null && Convert.ToString(prevNodeSelected.Tag) == "Katalogi")
                {
                }
                else
                {
                    this.ListViewPowiazane.WyswietlKolumnyKatalogi();
                }

                ListViewPowiazane.WyswietlKatalogi(Globalne.WczytaneKatalogi);

                this.ToolStripLab1.Text = string.Format("Liczba katalgów: {0} ({1})", Globalne.WczytaneKatalogi.LiczbaKatalogow.ToString(), Globalne.WczytaneKatalogi.RozmiarDanych.ToProperUnit());
                this.ToolStripLab2.Text = string.Format("Wylistowane elementy: {0} ({1})", Globalne.WczytaneKatalogi.LiczbaKatalogow.ToString(), Globalne.WczytaneKatalogi.RozmiarDanych.ToProperUnit());

            }
            else if (e.Node.Tag is Katalog)
            {
                if (prevNodeSelected != null && prevNodeSelected.Tag is Katalog)
                {
                }
                else
                {
                    this.ListViewPowiazane.WyswietlKolumnyNosniki();
                }
                Katalog temp = e.Node.Tag as Katalog;

                ListViewPowiazane.WyswietlZawartosKatalogu(temp);

                DostepnoscKatalogu(temp);


            }
            else if (e.Node.Tag is Nosnik)
            {
                if (prevNodeSelected != null && prevNodeSelected.Tag is Nosnik)
                {
                }
                else
                {
                    this.ListViewPowiazane.WyswietlKolumnyObiektyDyskowe();
                }
                Nosnik temp = (Nosnik)e.Node.Tag;

                ListViewPowiazane.WyswietlObiketyDyskowe(temp.Root.ObiektyDyskowe);

            }
            else if (e.Node.Tag is Folder)
            {
                if (prevNodeSelected != null && prevNodeSelected.Tag is Folder)
                {
                }
                else
                {

                    this.ListViewPowiazane.WyswietlKolumnyObiektyDyskowe();
                }
                Folder temp = e.Node.Tag as Folder;

                ListViewPowiazane.WyswietlObiketyDyskowe(temp.ObiektyDyskowe);


                }
                prevNodeSelected = e.Node;
            

        }

        protected override void OnBeforeExpand(TreeViewCancelEventArgs e)
        {
            base.OnBeforeExpand(e);
            if (Convert.ToString(e.Node.Tag).Equals("katalogi"))
            {
                if (e.Node.Nodes[0].Text == "*")
                {
                    e.Node.Nodes[0].Remove();
                    foreach (Katalog kat in Globalne.WczytaneKatalogi)
                    {
                        e.Node.Nodes.Add(new TreeNodeCataloger(kat));
                    }
                }
            }
            else if (e.Node.Tag is Katalog)
            {
                if (e.Node.Nodes[0].Text == "*")
                {
                    e.Node.Nodes[0].Remove();
                    foreach (Nosnik n in (e.Node.Tag as Katalog).Nosniki)
                    {
                        e.Node.Nodes.Add(new TreeNodeCataloger(n));
                    } 
                }
            }
            else if (e.Node.Tag is Nosnik)
            {
                if (e.Node.Nodes[0].Text == "*")
                {
                    e.Node.Nodes[0].Remove();
                    foreach (Folder f in (e.Node.Tag as Nosnik).Root.Podflodery)
                    {
                        e.Node.Nodes.Add(new TreeNodeCataloger(f));
                    } 
                }
            }
            else if (e.Node.Tag is Folder)
            {
                if (e.Node.Nodes[0].Text == "*")
                {
                    e.Node.Nodes[0].Remove();
                    foreach (Folder f in (e.Node.Tag as Folder).Podflodery)
                    {
                        e.Node.Nodes.Add(new TreeNodeCataloger(f));
                    } 
                }
            }
        }

        protected override void OnMouseDown(MouseEventArgs e)
        {
            base.OnMouseDown(e);
            if (e.Button == MouseButtons.Right)
            {
                Point p = new Point(e.X, e.Y);
                TreeNode node = this.GetNodeAt(p);
                if (node != null)
                {
                    this.SelectedNode = node;
                    if (Convert.ToString(node.Tag) == "Katalogi")
                    {
                        this.MenuKatalogi.Show(this, p);
                    }
                    else if (node.Tag is Katalog)
                    {
                        this.MenuKatalog.Show(this, p);
                    }
                    else if (node.Tag is Nosnik)
                    {
                        this.MenuNosnik.Show(this, p);
                    }
                    else if (node.Tag is Folder)
                    {
                        this.MenuFolder.Show(this, p);
                    }
                }
            }

        }

        protected override void OnMouseMove(MouseEventArgs e)
        {
            base.OnMouseMove(e);
            TreeNode currentNode = GetNodeAt(e.X, e.Y);
            if (currentNode != null)
            {
                if (currentNode != prevNode)
                {
                    if (currentNode.Tag is IInfo)
                    {
                        if (toolTipTree != null && toolTipTree.Active)
                        {
                            toolTipTree.Active = false;
                        }
                        toolTipTree.SetToolTip(this, (currentNode.Tag as IInfo).OpisToolTip);
                        toolTipTree.Active = true;

                    }
                    else if (currentNode.Text == "Katalogi")
                    {
                        if (toolTipTree != null && toolTipTree.Active)
                        {
                            toolTipTree.Active = false;
                        }
                        toolTipTree.SetToolTip(this, Globalne.WczytaneKatalogi.CalkowiteInfo);
                        toolTipTree.Active = true;
                    }       
                }
             }
            else
            {
                toolTipTree.SetToolTip(this, "");
            }
            prevNode = currentNode;
          
        }
		// Private Methods (5) 

        private void Initialize()
        {
            this.HideSelection = false;
            this.FullRowSelect = true;

            

            this.LabelEdit = false;
            this.ShowNodeToolTips = false;
            this.Dock = DockStyle.Fill;
            this.ItemHeight = 32;
            this.ImageList = UtworzImageList();
         //   this.Nodes.Clear();
        //    this.Nodes.Add(new TreeNodeCataloger("Katalogi"));
        }

        void kat_DodanoNosnik(object sender, NosnikEventArgs e)
        {
            ZaladujNosnik(e.nos);
        }

        void kat_UsunietoNosnik(object sender, NosnikEventArgs e)
        {
            WyladujNosnik(e.nos);
            
        }

        private void ustawieniaToolTip()
        {
            toolTipTree.InitialDelay = 1000;
            toolTipTree.ReshowDelay = 200;
            toolTipTree.AutoPopDelay = 3000;
        }

        private ImageList UtworzImageList()
        {
            ImageList imageLST = new ImageList();
            imageLST.ImageSize = new System.Drawing.Size(32, 32);
            imageLST.Images.Add("openFolder", Properties.Resources.openFolder);
            imageLST.Images.Add("closeFolder", Properties.Resources.closeFolder);
            imageLST.Images.Add("katalog", Properties.Resources.katalog);
            imageLST.Images.Add("katalogi", Properties.Resources.katalogi);
            imageLST.Images.Add("dyskTwardy", Properties.Resources.dyskTwardy);
            imageLST.Images.Add("dyskUSB", Properties.Resources.dyskUSB);
            imageLST.Images.Add("dyskSieciowy", Properties.Resources.dyskSieciowy);
            imageLST.Images.Add("dyskCDA", Properties.Resources.dyskCDA);
            imageLST.Images.Add("plytaCD", Properties.Resources.plytaCD);
            imageLST.Images.Add("dyskietka", Properties.Resources.dyskietka);
            imageLST.Images.Add("dyskSystemowy", Properties.Resources.dyskSystemowy);
            imageLST.Images.Add("dyskNieznany", Properties.Resources.dyskNieznany);
            return imageLST;
        }

		#endregion Methods


        #region IListaDrzewo Members

        public IObiektCatalogera ObiektZaznaczony
        {
            get
            {
                return this.SelectedNode.Tag as IObiektCatalogera;
            }
        }

        #endregion
    }
}
